#include "trap.h"
   .set noat
   .globl main
   .text
main:

# 为测试涉及到将返回地址存入ra寄存器的功能，需要修改reg.h
# 编译时会自动加上延迟槽，所以文件中没有写延迟槽
# t0~t9，以及a0、a1寄存器若均为0x1111_1111，则为测试通过

#J 无条件跳转
    j   J_TRUE
    
    J_TRUE:
        li $t0, 0x11111111        #$t0=0x11111111

#JR 无条件跳转 寄存器中的值
    li $s7, 0xbfc00020
    jr  $s7
    li $t8, 0x11111111

#JAL 无条件跳转 并 存入ra寄存器 && JALR 无条件跳转 寄存器中的值 并 存入ra寄存器
    jal JAL_TRUE
    li $a0, 0x11111111

    addi $s6, $ra, 0x14
    jalr $ra, $s6
    li $a1, 0x11111111
    j   BEQ_CASE0

    jr $ra

    JAL_TRUE:
        jr  $ra

#BEQ 相等跳转
    BEQ_CASE0:                      #### 0==0
        li $t1, 0x0
        li $s0, 0x0
        beq $s0, $zero, BEQ_CASE1        # 相等就跳转到CASE1进行下一个情况的测试
        j   FALSE                      #否则就跳转到false
    BEQ_CASE1:                      #### 正负
        li $t1, 0x1                       #顺利进入case1
        li $s1, 0x10000001
        li $s2, 0xffffffff
        beq $s1, $s2, FALSE
        j   BEQ_CASE2
    BEQ_CASE2:                      #### 正正
        li $t1, 0x2
        li $s3, 0x10000001
        beq $s1, $s3, BEQ_CASE3
        j   FALSE
    BEQ_CASE3:                      #### 负负
        li $t1, 0x3
        li $s4, 0xffffffff
        beq $s2, $s4, BEQ_CASE4
        j   FALSE
    BEQ_CASE4:                      #### 正0
        li $t1, 0x4
        beq $s1, $zero, FALSE
        j   BEQ_CASE5
    BEQ_CASE5:                      #### 负0
        li $t1, 0x5
        beq $s2, $zero, FALSE
        li $t1, 0x11111111              #$t1应该为0x11111111
        j   BNE_CASE0

#BNE 不相等跳转
    BNE_CASE0:                      #### 0==0
        li $t2, 0x0
        bne $s0, $zero, FALSE        
        j   BNE_CASE1
    BNE_CASE1:                      #### 正负
        li $t2, 0x1
        bne $s1, $s2, BNE_CASE2
        j   FALSE
    BNE_CASE2:                      #### 正正
        li $t2, 0x2
        li $s5, 0x00010086
        bne $s1, $s5, BNE_CASE3
        j   FALSE
    BNE_CASE3:                      #### 负负
        li $t2, 0x3
        li $s6, 0xfafafafa
        bne $s2, $s6, BNE_CASE4
        j   FALSE
    BNE_CASE4:                      #### 正0
        li $t2, 0x4
        bne $s1, $zero, BNE_CASE5
        j   FALSE
    BNE_CASE5:                      #### 负0
        li $t2,0x5
        bne $s2, $zero, BGEZ_CASE0
        j   FALSE

#BGEZ 大于等于0跳转
    BGEZ_CASE0:                     #### 等于0
        li $t2, 0x11111111
        li $t3, 0x0
        bgez $zero, BGEZ_CASE1
        j   FALSE
    BGEZ_CASE1:                     #### 大于0（最大正数）
        li $t3, 0x1
        li $s7, 0x7fffffff
        bgez $s7, BGEZ_CASE2
        j   FALSE
    BGEZ_CASE2:                     #### 小于0（最小负数）
        li $t3, 0x2
        li $v0, 0x80000000
        bgez $v0, FALSE
        li $t3, 0x11111111
        j   BGTZ_CASE0

#BGTZ 大于0跳转
    BGTZ_CASE0:                     #### 等于0
        li $t4, 0x0
        bgtz $zero, FALSE
        j   BGTZ_CASE1
    BGTZ_CASE1:                     #### 大于0（最大正数）
        li $t4, 0x1
        bgtz $s7, BGTZ_CASE2
        j   FALSE
    BGTZ_CASE2:                     #### 小于0（最小负数）
        li $t4, 0x2
        bgtz $v0, FALSE
        li $t4, 0x11111111
        j   BLEZ_CASE0

#BLEZ 小于等于0跳转
    BLEZ_CASE0:                     #### 等于0
        li $t5, 0x0
        blez $zero, BLEZ_CASE1
        j   FALSE
    BLEZ_CASE1:                     #### 小于0（最小负数）
        li $t5, 0x1
        blez $v0, BLEZ_CASE2
        j   FALSE
    BLEZ_CASE2:
        li $t5, 0x2
        blez $s7, FALSE             #### 大于0（最大正数）
        li $t5, 0x11111111
        j   BLTZ_CASE0

#BLTZ 小于0跳转
    BLTZ_CASE0:                     #### 等于0
        li $t6, 0x0
        bltz $zero, FALSE
        j   BLTZ_CASE1
    BLTZ_CASE1:                     #### 小于0（最小负数）
        li $t6, 0X1
        bltz $v0, BLTZ_CASE2
        j   FALSE
    BLTZ_CASE2:                     #### 大于0（最大正数）
        li $t6, 0x2
        bltz $s7, FALSE
        li $t6, 0x11111111
        j   BGEZAL_CASE0
#BGEZAL 大于等于0跳转 并 保存返回地址
    BGEZAL_CASE0:                   #### 等于0
        li $t7, 0x0
        bgezal $zero, AL_TRUE
        j   FALSE
    BGEZAL_CASE1:                   #### 小于0（最小负数）
        li $t7, 0x1
        bgezal $v0, AL_FALSE
        j   BGEZAL_CASE2
        j   FALSE
    BGEZAL_CASE2:                   #### 大于0（最大正数）
        li $t7, 0x2
        bgezal $s7, AL_TRUE
        j   FALSE
        li $t7, 0x11111111
        j   BLTZAL_CASE0

#BLTZAL 小于0跳转 并 保存返回地址
    BLTZAL_CASE0:                   #### 等于0
        li $t9, 0x0
        bltzal $zero, AL_FALSE
        j   BLTZAL_CASE1
        j   FALSE
    BLTZAL_CASE1:                   #### 大于0（最大正数）
        li $t9, 0x1
        bltzal $s7, AL_FALSE
        j   BLTZAL_CASE2
        j   FALSE
    BLTZAL_CASE2:                   #### 小于0（最小负数）
        li $t9, 0x2
        bltzal $v0, AL_TRUE
        j   FALSE
        li $t9, 0x11111111
        j   SUCCESS                  

AL_TRUE:
    addi $ra, $ra, 0x4
    jr  $ra
AL_FALSE:
    addi $ra, $ra, 0x4
    jr  $ra
FALSE:
    HIT_BAD_TRAP
SUCCESS:
    HIT_GOOD_TRAP		#stop temu
